home *** CD-ROM | disk | FTP | other *** search
/ Ultimedia 2 / Ultimedia 2.iso / tools / animplayer / amipeg / source.lha / util.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-03  |  6.2 KB  |  305 lines
  1. /*
  2.  *  This file handles filling of the buffer and contains some additional utility routines.
  3.  */
  4.  
  5. #include "video.h"
  6. #include "proto.h"
  7. #include "util.h"
  8.  
  9. /* Declarations of global variables used. */
  10.  
  11. int bitOffset;
  12. int bufLength;
  13. unsigned int *bitBuffer;
  14.  
  15.  
  16. /*
  17.  *--------------------------------------------------------------
  18.  *
  19.  * correct_underflow --
  20.  *
  21.  *    Called when buffer does not have sufficient data to 
  22.  *      satisfy request for bits.
  23.  *      Calls get_more_data, an application specific routine
  24.  *      required to fill the buffer with more data.
  25.  *
  26.  * Results:
  27.  *      None really.
  28.  *  
  29.  * Side effects:
  30.  *    buf_length and buffer fields in curVidStream structure
  31.  *      may be changed.
  32.  *
  33.  *--------------------------------------------------------------
  34.  */
  35.  
  36. void correct_underflow(void)
  37. {
  38.   int status;
  39.  
  40.   status = get_more_data(curVidStream->buf_start, curVidStream->max_buf_length, &bufLength, &bitBuffer);
  41.  
  42.   if (status  < 0) {
  43.     if (!quietFlag) {
  44.       fprintf (stderr, "\n");
  45.       perror("Unexpected read error.");
  46.     }
  47.     exit(1);
  48.   }
  49.   else if ((status == 0) && (bufLength < 1)) {
  50.     if (!quietFlag) {
  51.       fprintf(stderr, "\nImproper or missing sequence end code.\n");
  52.     }
  53. #ifdef ANALYSIS
  54.     PrintAllStats();
  55. #endif
  56.     if (!quietFlag) {
  57.       PrintTimeInfo();
  58.     }
  59.  
  60.     if (loopFlag) longjmp(env, 1);
  61.     DestroyVidStream(curVidStream);
  62.     exit(0);
  63.   }
  64.  
  65. }
  66.  
  67.  
  68. /*
  69.  *--------------------------------------------------------------
  70.  *
  71.  * get_ext_data --
  72.  *
  73.  *    Assumes that bit stream is at begining of extension
  74.  *      data. Parses off extension data into dynamically 
  75.  *      allocated space until start code is hit. 
  76.  *
  77.  * Results:
  78.  *    Pointer to dynamically allocated memory containing
  79.  *      extension data.
  80.  *
  81.  * Side effects:
  82.  *    Bit stream irreversibly parsed.
  83.  *
  84.  * Niceness -10000 !!!!
  85.  *
  86.  *--------------------------------------------------------------
  87.  */
  88.  
  89. char *get_ext_data (void)
  90. {
  91.   int size, marker;
  92.   char *dataPtr;
  93.   unsigned int data;
  94.  
  95.   /* Set initial ext data buffer size. */
  96.  
  97.   size = EXT_BUF_SIZE;
  98.  
  99.   /* Allocate ext data buffer. */
  100.  
  101.   dataPtr = (char *) malloc(size);
  102.  
  103.   /* Initialize marker to keep place in ext data buffer. */
  104.  
  105.   marker = 0;
  106.  
  107.   /* While next data is not start code... */
  108.   while ((show_bitsn(24,data)) != 0x000001) {                /* data re-usage could be applied ! */
  109.  
  110.     /* Put ext data into ext data buffer. Advance marker. */
  111.  
  112.     get_bits8( dataPtr[marker] );
  113.     marker++;
  114.  
  115.     /* If end of ext data buffer reached, resize data buffer. */
  116.  
  117.     if (marker == size) {
  118.       size += EXT_BUF_SIZE;
  119.       dataPtr = (char *) realloc(dataPtr, size);
  120.     }
  121.   }
  122.  
  123.   /* Realloc data buffer to free any extra space. */
  124.  
  125.   dataPtr = (char *) realloc(dataPtr, marker);
  126.  
  127.   /* Return pointer to ext data buffer. */
  128.  
  129.   return dataPtr;
  130. }
  131.  
  132.  
  133. /*
  134.  *--------------------------------------------------------------
  135.  *
  136.  * next_start_code --
  137.  *
  138.  *    Parses off bitstream until start code reached. When done
  139.  *      next 4 bytes of bitstream will be start code. Bit offset
  140.  *      reset to 0.
  141.  *
  142.  * Results:
  143.  *    Status code.
  144.  *
  145.  * Side effects:
  146.  *    Bit stream irreversibly parsed.
  147.  *
  148.  *--------------------------------------------------------------
  149.  */
  150.  
  151. int next_start_code(void)
  152. {
  153.   int state;
  154.   int byteoff;
  155.   unsigned int data;
  156.  
  157.   /* If no current stream, return error. */
  158.  
  159.   if (curVidStream == NULL) return NO_VID_STREAM;
  160.  
  161.   /* If insufficient buffer length, correct underflow. */
  162.  
  163.   if (bufLength < 2) {
  164.     correct_underflow();
  165.   }
  166.  
  167.   /* If bit offset not zero, reset and advance buffer pointer. */
  168.  
  169.   byteoff = bitOffset & 7;
  170.  
  171.   if (byteoff != 0) {
  172.     flush_bits((8-byteoff));
  173.   }
  174.  
  175.   /* Set state = 0. */
  176.  
  177.   state = 0;
  178.  
  179.   /* While buffer has data ... */
  180.  
  181.   while(bufLength > 0) {
  182.  
  183.     /* If insufficient data exists, correct underflow. */
  184.  
  185.     if (bufLength < 2) {
  186.       correct_underflow();
  187.     }
  188.  
  189.     /* If next byte is zero... */
  190.  
  191.     get_bits8(data);
  192.  
  193.     if (data == 0) {
  194.       if (state < 2) state++;            /* If state < 2, advance state. */
  195.     }
  196.     /* If next byte is one... */
  197.     else if (data == 1) {
  198.       if (state == 2) state++;            /* If state == 2, advance state (i.e. start code found). */
  199.       /* Otherwise, reset state to zero. */
  200.       else state = 0;
  201.     }
  202.     /* Otherwise byte is neither 1 or 0, reset state to 0. */
  203.     else {
  204.       state = 0;
  205.     }
  206.     if (state == 3) {                /* If state == 3 (i.e. start code found)... */
  207.  
  208.       /* Set buffer pointer back and reset length & bit offsets so
  209.      next bytes will be beginning of start code. 
  210.       */
  211.  
  212.       bitOffset -= 24;
  213.  
  214. #ifdef ANALYSIS
  215.       bitCount -= 24;
  216. #endif
  217.  
  218.       if (bitOffset < 0) {
  219.     bitOffset += 32;
  220.     bufLength++;
  221.     bitBuffer--;
  222.       }
  223.  
  224.       /* Return success. */
  225.  
  226.       return OK;
  227.     }
  228.   }
  229.  
  230.   /* Return underflow error. */
  231.  
  232.   return UNDERFLOW;
  233. }
  234.  
  235.  
  236. /*
  237.  *--------------------------------------------------------------
  238.  *
  239.  * get_extra_bit_info --
  240.  *
  241.  *    Parses off extra bit info stream into dynamically 
  242.  *      allocated memory. Extra bit info is indicated by
  243.  *      a flag bit set to 1, followed by 8 bits of data.
  244.  *      This continues until the flag bit is zero. Assumes
  245.  *      that bit stream set to first flag bit in extra
  246.  *      bit info stream.
  247.  *
  248.  * Results:
  249.  *    Pointer to dynamically allocated memory with extra
  250.  *      bit info in it. Flag bits are NOT included.
  251.  *
  252.  * Side effects:
  253.  *    Bit stream irreversibly parsed.
  254.  *
  255.  *--------------------------------------------------------------
  256.  */
  257.  
  258. char *get_extra_bit_info (void)
  259. {
  260.   int size, marker;
  261.   char *dataPtr;
  262.   unsigned int data;
  263.  
  264.   /* Get first flag bit; if flag is false, return NULL pointer (i.e. no extra bit info). */
  265.  
  266.   if (!(get_bits1(data))) return NULL;
  267.  
  268.   /* Initialize size of extra bit info buffer and allocate. */
  269.  
  270.   size = EXT_BUF_SIZE;
  271.   dataPtr = (char *) malloc(size);
  272.  
  273.   /* Reset marker to hold place in buffer. */
  274.  
  275.   marker = 0;
  276.  
  277.   /* While flag bit is true. */
  278.  
  279.   while (data) {
  280.  
  281.     /* Place in extra bit info buffer. */
  282.  
  283.     get_bits8( dataPtr[marker] );
  284.     marker++;
  285.  
  286.     /* If buffer is full, reallocate. */
  287.  
  288.     if (marker == size) {
  289.       size += EXT_BUF_SIZE;
  290.       dataPtr = (char *) realloc(dataPtr, size);
  291.     }
  292.  
  293.     /* Get next flag bit. */
  294.     get_bits1(data);
  295.   }
  296.  
  297.   /* Reallocate buffer to free extra space. */
  298.  
  299.   dataPtr = (char *) realloc(dataPtr, marker);
  300.  
  301.   /* Return pointer to extra bit info buffer. */
  302.  
  303.   return dataPtr;
  304. }
  305.